home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / interfaces / PInterface Translator / PInterfaces / PasLibIntf.p < prev    next >
Encoding:
Text File  |  1993-09-16  |  4.7 KB  |  219 lines  |  [TEXT/MPS ]
  1. {*-------------------------------------------------------------------------------*
  2.  |                                                                                 |
  3.  |                          <<< Pascal Library Interface >>>                         |
  4.  |                                                                                 |
  5.  |                        Copyright Apple Computer, Inc. 1986                      |
  6.  |                               All rights reserved.                              |
  7.  |                                                                                 |
  8.  *-------------------------------------------------------------------------------*}
  9.  
  10. {
  11.  Interface to the Pascal I/O and Memory Manager Library.
  12.  Built-in procedure and function declarations are marked with
  13.  the (* *) comment characters
  14. }
  15.  
  16. {$IFC UNDEFINED UsingIncludes}
  17. {$SETC UsingIncludes := 0}
  18. {$ENDC}
  19.  
  20. {$IFC NOT UsingIncludes}
  21.     UNIT PASLIBIntf;
  22.       INTERFACE
  23. {$ENDC}
  24.  
  25. {$IFC UNDEFINED UsingPASLIBINTF}
  26. {$SETC UsingPASLIBINTF := 1}
  27.  
  28. {$I+}
  29. {$SETC PASLIBINTFIncludes := UsingIncludes}
  30. {$SETC UsingIncludes := 1}
  31. {$IFC UNDEFINED UsingTypes}
  32. {$I $$Shell(PInterfaces)Types.p}
  33. {$ENDC}
  34. {$SETC UsingIncludes := PASLIBINTFIncludes}
  35.  
  36.     TYPE
  37.       PASCALPOINTER = ^INTEGER; { Universal POINTER type }
  38.       PASCALFILE = FILE; { Universal FILE type }
  39. (*
  40.  *      PASCALBLOCK =    { Universal block of chars }
  41.  *            PACKED ARRAY [0..511] OF CHAR;
  42.  *)
  43.  
  44.     CONST
  45.       { <StdIO.h> PLSetVBuf styles }
  46.       _IOFBF = $00; { File buffering }
  47.       _IOLBF = $40; { Line buffering }
  48.       _IONBF = $04; { No buffering }
  49.  
  50. {
  51.  Mac Pascal heap management
  52. }
  53.  
  54.     PROCEDURE PLHeapInit(sizepheap: LONGINT; heapDelta: LONGINT;
  55.                          memerrProc: UNIV PASCALPOINTER; allowNonCont: BOOLEAN;
  56.                          forDispose: BOOLEAN);
  57. {
  58.  The following procedure is obsolete, use PLHeapInit
  59. }
  60.  
  61.     PROCEDURE PLInitHeap(sizepheap: LONGINT; memerrProc: UNIV PASCALPOINTER;
  62.                          allowNonCont: BOOLEAN; allowDispose: BOOLEAN);
  63.  
  64.     PROCEDURE PLSetNonCont(allowNonCont: BOOLEAN);
  65.  
  66.     PROCEDURE PLSetMErrProc(memerrProc: UNIV PASCALPOINTER);
  67.  
  68.     PROCEDURE PLSetHeapType(forDispose: BOOLEAN);
  69.  
  70.     PROCEDURE PLSetHeapCheck(DoIt: BOOLEAN);
  71.  
  72. {
  73.  File I/O
  74. }
  75.  
  76. (*
  77.  *      PROCEDURE
  78.  *        RESET(VAR fvar:  UNIV PASCALFILE; OPT fname: STRING);
  79.  *        BUILTIN;
  80.  *
  81.  *      PROCEDURE
  82.  *        REWRITE(VAR fvar: UNIV PASCALFILE; OPT fname: STRING);
  83.  *        BUILTIN;
  84.  *
  85.  *      PROCEDURE
  86.  *        OPEN(VAR fvar:    UNIV PASCALFILE; fname: STRING);
  87.  *        BUILTIN;
  88.  *)
  89.  
  90.     PROCEDURE PLSetVBuf(VAR fvar: TEXT; buffer: UNIV PASCALPOINTER;
  91.                         style: INTEGER; bufsize: INTEGER);
  92. (*
  93.  *      FUNCTION
  94.  *        BLOCKREAD(
  95.  *          VAR fvar: FILE;
  96.  *          VAR buffer: UNIV PASCALBLOCK;
  97.  *          nBlocks: INTEGER;
  98.  *          OPT stBlock:INTEGER
  99.  *        ):
  100.  *        INTEGER;
  101.  *        BUILTIN;
  102.  *
  103.  *      FUNCTION
  104.  *        BLOCKWRITE(
  105.  *          VAR fvar: FILE;
  106.  *          VAR buffer: UNIV PASCALBLOCK;
  107.  *          nBlocks: INTEGER;
  108.  *          OPT stBlock:INTEGER
  109.  *        ):
  110.  *        INTEGER;
  111.  *        BUILTIN;
  112.  *
  113.  *      FUNCTION
  114.  *        BYTEREAD(
  115.  *          VAR fvar: FILE;
  116.  *          VAR buffer: UNIV PASCALBLOCK;
  117.  *          nBytes:  LONGINT;
  118.  *          OPT stByte: LONGINT
  119.  *        ):
  120.  *        LONGINT;
  121.  *        BUILTIN;
  122.  *
  123.  *      FUNCTION
  124.  *        BYTEWRITE(
  125.  *          VAR fvar: FILE;
  126.  *          VAR buffer: UNIV PASCALBLOCK;
  127.  *          nBytes:  LONGINT;
  128.  *          OPT stByte: LONGINT
  129.  *        ):
  130.  *        LONGINT;
  131.  *        BUILTIN;
  132.  *
  133.  *      FUNCTION
  134.  *        EOF(OPT VAR fvar: UNIV PASCALFILE):
  135.  *        BOOLEAN;
  136.  *        BUILTIN;
  137.  *
  138.  *      FUNCTION
  139.  *        EOLN(OPT VAR fvar: TEXT):
  140.  *        BOOLEAN;
  141.  *        BUILTIN;
  142.  *
  143.  *      PROCEDURE
  144.  *        READ(VAR fvar: TEXT; OPT EXPR_LIST);
  145.  *        BUILTIN;
  146.  *
  147.  *      PROCEDURE
  148.  *        READLN(OPT VAR fvar: TEXT; OPT EXPR_LIST);
  149.  *        BUILTIN;
  150.  *
  151.  *      PROCEDURE
  152.  *        WRITE(VAR fvar: TEXT; OPT EXPR_LIST);
  153.  *        BUILTIN;
  154.  *
  155.  *      PROCEDURE
  156.  *        WRITELN(OPT VAR fvar: TEXT; OPT EXPR_LIST);
  157.  *        BUILTIN;
  158.  *
  159.  *      PROCEDURE
  160.  *        GET(VAR fvar: UNIV PASCALFILE);
  161.  *        BUILTIN;
  162.  *
  163.  *      PROCEDURE
  164.  *        PUT(VAR fvar: UNIV PASCALFILE);
  165.  *        BUILTIN;
  166.  *
  167.  *      PROCEDURE
  168.  *        SEEK(VAR fvar: UNIV PASCALFILE; recno: LONGINT);
  169.  *        BUILTIN;
  170.  *)
  171.  
  172.     FUNCTION PLFilePos(VAR fvar: UNIV PASCALFILE): LONGINT;
  173.  
  174.     PROCEDURE PLFlush(VAR fvar: TEXT);
  175.  
  176.     PROCEDURE PLCrunch(VAR fvar: UNIV PASCALFILE);
  177. {
  178.  Directory operations.
  179. }
  180.  
  181.     PROCEDURE PLPurge(fname: STRING);
  182.  
  183.     PROCEDURE PLRename(oldFname, newFname: STRING);
  184.  
  185. {
  186.  C string functions for Pascal strings
  187. }
  188.      FUNCTION PLStrCmp(string1, string2: STR255): INTEGER;
  189.  
  190.     FUNCTION PLStrnCmp(string1, string2: STR255; n: INTEGER): INTEGER;
  191.  
  192.     FUNCTION PLStrCpy(VAR string1: STR255; string2: STR255): STRINGPTR;
  193.  
  194.     FUNCTION PLStrnCpy(VAR string1: STR255; string2: STR255; n: INTEGER): STRINGPTR;
  195.  
  196.     FUNCTION PLStrCat(VAR string1: STR255; string2: STR255): STRINGPTR;
  197.  
  198.     FUNCTION PLStrnCat(VAR string1: STR255; string2: STR255; n: INTEGER): STRINGPTR;
  199.  
  200.     FUNCTION PLStrChr(string1: STR255; c: CHAR): PTR;
  201.  
  202.     FUNCTION PLStrrChr(string1: STR255; c: CHAR): PTR;
  203.  
  204.     FUNCTION PLStrPBrk(string1, string2: STR255): PTR;
  205.  
  206.     FUNCTION PLStrSpn(string1, string2: STR255): INTEGER;
  207.  
  208.     FUNCTION PLStrStr(string1, string2: STR255): PTR;
  209.  
  210.     FUNCTION PLStrLen(string1: STR255): INTEGER;
  211.     
  212.     FUNCTION PLPos(STRING1: STR255; STRING2: STR255): INTEGER;
  213.  
  214. {$ENDC}    { UsingPASLIBINTF }
  215.  
  216. {$IFC NOT UsingIncludes}
  217.     END.
  218. {$ENDC}
  219.